// ==UserScript==
// @name         sl-太平保险信息浮窗切换环节功能
// @namespace    http://tampermonkey.net/
// @version      1.1
// @description  合并产品信息浮窗和跳过播报自动聚焦功能，支持配置开关
// @author       gt
// @include      https://tpsl.life.cntaiping.com/*
// @icon         
// @grant        none
// @updateURL    https://gitee.com/i-recruit-handsome/i-attract-good-fortune/raw/master/sl-gt_taiping.user.js
// @downloadURL  https://gitee.com/i-recruit-handsome/i-attract-good-fortune/raw/master/sl-gt_taiping.user.js
// ==/UserScript==

(function () {
    'use strict';

    // ==================== 配置项 ====================
    const CONFIG = {
        // 产品信息浮窗功能开关
        enableProductFloat: true,

        // 跳过播报自动聚焦功能开关
        enableSkipBroadcast: true,

        // 键盘快捷键开关
        enableKeyboardShortcuts: true,

        // 回车键自动跳转开关
        enableEnterAutoJump: true,

        // 鼠标点击自动跳转开关（已默认关闭）
        enableClickAutoJump: false
    };

    // ==================== 产品信息浮窗功能 ====================
    let lastProductInfo = ''; // 记录上次的产品信息
    let updateTimeout = null; // 防抖定时器
    let isUpdating = false; // 防止递归更新

    // 提取产品信息的函数
    function extractProductInfo() {
        if (!CONFIG.enableProductFloat) return null;

        // 获取所有产品信息元素
        const productElements = document.querySelectorAll('[data-v-55875e22].every-product');
        if (!productElements || productElements.length === 0) return null;

        let salesPersonName = "";
        let policyHolders = []; // 存储所有投保人信息
        let insuredPersons = []; // 存储所有被保人信息

        // 销售人员信息提取
        const sellStyles = document.querySelectorAll('[data-v-55875e22].sell-style');
        sellStyles.forEach((sellStyle) => {
            const headerSpan = sellStyle.querySelector('span[data-v-55875e22]');
            if (headerSpan?.textContent.includes('销售人员信息')) {
                const salesContent = sellStyle.nextElementSibling?.querySelector('[data-v-55875e22].every-content');
                if (salesContent) {
                    const infoDivs = salesContent.querySelectorAll('[data-v-55875e22]');
                    infoDivs.forEach((div) => {
                        if (div.textContent.includes('姓名：')) {
                            salesPersonName = div.textContent.replace('姓名：', '').trim();
                        }
                    });
                }
            }
        });

        // 投保人信息提取（支持多个投保人）
        sellStyles.forEach((sellStyle) => {
            const headerSpan = sellStyle.querySelector('span[data-v-55875e22]');
            if (headerSpan?.textContent.includes('投保人信息')) {
                // 查找投保人信息标题后的所有相关容器
                let currentElement = sellStyle.nextElementSibling;

                // 遍历投保人信息标题后的所有兄弟元素
                while (currentElement) {
                    // 检查当前元素本身是否是sell-content
                    if (currentElement.classList && currentElement.classList.contains('sell-content')) {
                        const policyContents = currentElement.querySelectorAll('[data-v-55875e22].every-content');
                        policyContents.forEach((policyContent) => {
                            let name = '', age = '';
                            const infoDivs = policyContent.querySelectorAll('[data-v-55875e22]');
                            infoDivs.forEach((div) => {
                                if (div.textContent.includes('姓名：')) name = div.textContent.replace('姓名：', '').trim();
                                if (div.textContent.includes('年龄：')) age = div.textContent.match(/年龄：(\d+)/)?.[1] || '未知';
                            });
                            if (name) {
                                policyHolders.push({ name, age });
                            }
                        });
                    } else {
                        // 检查当前元素是否包含投保人信息
                        const sellContents = currentElement.querySelectorAll('[data-v-55875e22].sell-content');
                        if (sellContents.length > 0) {
                            sellContents.forEach((sellContent) => {
                                const policyContents = sellContent.querySelectorAll('[data-v-55875e22].every-content');
                                policyContents.forEach((policyContent) => {
                                    let name = '', age = '';
                                    const infoDivs = policyContent.querySelectorAll('[data-v-55875e22]');
                                    infoDivs.forEach((div) => {
                                        if (div.textContent.includes('姓名：')) name = div.textContent.replace('姓名：', '').trim();
                                        if (div.textContent.includes('年龄：')) age = div.textContent.match(/年龄：(\d+)/)?.[1] || '未知';
                                    });
                                    if (name) {
                                        policyHolders.push({ name, age });
                                    }
                                });
                            });
                        }
                    }

                    // 移动到下一个兄弟元素，但如果遇到新的sell-style标题则停止
                    currentElement = currentElement.nextElementSibling;
                    if (currentElement && currentElement.classList.contains('sell-style')) {
                        break;
                    }
                }
            }
        });

        // 被保人信息提取（支持多个被保人）
        sellStyles.forEach((sellStyle) => {
            const headerSpan = sellStyle.querySelector('span[data-v-55875e22]');
            if (headerSpan?.textContent.includes('被保人信息')) {
                // 查找被保人信息标题后的所有相关容器
                let currentElement = sellStyle.nextElementSibling;

                // 遍历被保人信息标题后的所有兄弟元素
                while (currentElement) {
                    // 检查当前元素本身是否是sell-content
                    if (currentElement.classList && currentElement.classList.contains('sell-content')) {
                        const insuredContents = currentElement.querySelectorAll('[data-v-55875e22].every-content');
                        insuredContents.forEach((insuredContent) => {
                            let name = '', age = '';
                            const infoDivs = insuredContent.querySelectorAll('[data-v-55875e22]');
                            infoDivs.forEach((div) => {
                                if (div.textContent.includes('姓名：')) name = div.textContent.replace('姓名：', '').trim();
                                if (div.textContent.includes('年龄：')) age = div.textContent.match(/年龄：(\d+)/)?.[1] || '未知';
                            });
                            if (name) {
                                insuredPersons.push({ name, age });
                            }
                        });
                    } else {
                        // 检查当前元素是否包含被保人信息
                        const sellContents = currentElement.querySelectorAll('[data-v-55875e22].sell-content');
                        if (sellContents.length > 0) {
                            sellContents.forEach((sellContent) => {
                                const insuredContents = sellContent.querySelectorAll('[data-v-55875e22].every-content');
                                insuredContents.forEach((insuredContent) => {
                                    let name = '', age = '';
                                    const infoDivs = insuredContent.querySelectorAll('[data-v-55875e22]');
                                    infoDivs.forEach((div) => {
                                        if (div.textContent.includes('姓名：')) name = div.textContent.replace('姓名：', '').trim();
                                        if (div.textContent.includes('年龄：')) age = div.textContent.match(/年龄：(\d+)/)?.[1] || '未知';
                                    });
                                    if (name) {
                                        insuredPersons.push({ name, age });
                                    }
                                });
                            });
                        }
                    }

                    // 移动到下一个兄弟元素，但如果遇到新的sell-style标题则停止
                    currentElement = currentElement.nextElementSibling;
                    if (currentElement && currentElement.classList.contains('sell-style')) {
                        break;
                    }
                }
            }
        });

        // 处理所有产品信息
        const productTexts = Array.from(productElements).map(element => {
            let text = element.textContent.trim();
            // 去掉产品编号（如1276——）和后缀（如——分红险——寿险）
            text = text.replace(/^\d+——/, ''); // 去掉开头的数字和——
            text = text.replace(/——[^——]*——[^——]*$/, ''); // 去掉末尾的——分红险——寿险
            return text;
        });

        // 所有产品信息用 | 分隔符在一行内显示
        const productText = productTexts.join(' | ') || '';

        return {
            productText,
            salesPersonName,
            policyHolders,
            insuredPersons
        };
    }

    // 更新浮窗的函数
    function updateFloatWindow(productInfo) {
        if (isUpdating || !CONFIG.enableProductFloat) return; // 防止递归
        isUpdating = true;

        // 构建显示文本
        // 格式化投保人信息
        const policyHolderText = productInfo.policyHolders.length > 0
            ? productInfo.policyHolders.map(p => `${p.name}(${p.age}岁)`).join('、')
            : '无';

        // 格式化被保人信息
        const insuredPersonText = productInfo.insuredPersons.length > 0
            ? productInfo.insuredPersons.map(p => `${p.name}(${p.age}岁)`).join('、')
            : '无';

        const combinedText = `产品信息: ${productInfo.productText}\n销售人: ${productInfo.salesPersonName}\n投保人: ${policyHolderText} | 被保人: ${insuredPersonText}`;

        // 检查信息是否有变化
        if (combinedText === lastProductInfo) {
            isUpdating = false;
            return;
        }

        lastProductInfo = combinedText;

        let floatWindow = document.querySelector('#product-float-window');

        if (!floatWindow) {
            // 创建新浮窗
            floatWindow = document.createElement('div');
            floatWindow.id = 'product-float-window';
            floatWindow.style.cssText = `
                /* === 浮窗基础定位设置 === */
                position: fixed;                    /* 固定定位，不随页面滚动 */

                /* === 浮窗位置设置（重要：修改这两个值来调整浮窗位置）=== */
                left: 5px;                         /* 距离左边的距离，增大数值向右移动 */
                top: 40px;                         /* 距离顶部的距离，增大数值向下移动 */

                /* === 浮窗背景和边框设置 === */
                background: transparent;            /* 背景透明，不遮挡视频内容 */
                border: none;                      /* 无边框 */
                border-radius: 0;                  /* 无圆角 */
                box-shadow: none;                  /* 无阴影效果 */

                /* === 浮窗尺寸和内边距设置 === */
                max-width: 600px;                 /* 最大宽度，防止内容过长 */
                padding: 8px 12px;                /* 内边距：上下8px，左右12px */

                /* === 文字样式设置（重要：修改这些值来调整文字外观）=== */
                font-size: 12px;                  /* 文字大小，增大数值文字更大 */
                font-weight: 350;                 /* 文字粗细：100-900，数值越大越粗 */
                line-height: 1.4;                 /* 行高，控制行间距 */
                color: #ffffff;                    /* 文字颜色：白色，可改为其他颜色如 #ff0000(红色) */
                text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.8); /* 文字阴影：右1px下1px模糊2px黑色80%透明度 */

                /* === 其他显示设置 === */
                z-index: 10000;                   /* 层级，确保浮窗在最上层显示 */
                white-space: pre-line;             /* 保留换行符，支持多行显示 */
                -webkit-text-size-adjust: none;    /* 禁止移动端自动调整文字大小 */
            `;
            document.body.appendChild(floatWindow);
        }

        // 更新内容（多行显示，保留换行）
        floatWindow.innerHTML = combinedText.replace(/\n/g, '<br>');

        isUpdating = false;
    }

    // 移除浮窗的函数
    function removeFloatWindow() {
        if (isUpdating) return;
        isUpdating = true;

        const existingWindow = document.querySelector('#product-float-window');
        if (existingWindow) {
            existingWindow.remove();
            lastProductInfo = '';
        }

        isUpdating = false;
    }

    // 防抖处理函数
    function handleUpdate() {
        if (!CONFIG.enableProductFloat) return;

        if (updateTimeout) {
            clearTimeout(updateTimeout);
        }

        updateTimeout = setTimeout(() => {
            const productInfo = extractProductInfo();

            if (productInfo) {
                updateFloatWindow(productInfo);
            } else {
                removeFloatWindow();
            }
        }, 100); // 100ms防抖
    }

    // ==================== 跳过播报自动聚焦功能 ====================
    let currentFocusedButton = null;
    let isProcessing = false; // 防止递归调用
    const HIGHLIGHT_CLASS = 'skip-broadcast-highlight';

    // 添加样式
    function addSkipBroadcastStyles() {
        if (!CONFIG.enableSkipBroadcast || document.getElementById('skip-broadcast-styles')) return;

        const style = document.createElement('style');
        style.id = 'skip-broadcast-styles';
        style.textContent = `
            .${HIGHLIGHT_CLASS} {
                border: 3px solid #FFD700 !important;
                box-shadow: 0 0 10px #FFD700 !important;
                background-color: rgba(255, 215, 0, 0.1) !important;
                transition: all 0.2s ease !important;
                position: relative !important;
                z-index: 9999 !important;
            }
        `;
        document.head.appendChild(style);
    }

    // 核心函数：获取所有目标按钮
    function getTargetButtons() {
        if (!CONFIG.enableSkipBroadcast) return [];

        const buttons = [];

        // 查找所有button元素
        document.querySelectorAll('button').forEach(btn => {
            if (btn.offsetParent !== null && // 确保可见
                btn.textContent.includes('跳过播报') &&
                btn.querySelector('img')) {
                buttons.push(btn);
            }
        });

        // 如果没找到button，查找其他可能的容器
        if (buttons.length === 0) {
            document.querySelectorAll('*').forEach(el => {
                if (el.offsetParent !== null &&
                    el.textContent.trim().includes('跳过播报') &&
                    el.querySelector('img') &&
                    (el.tagName === 'DIV' || el.tagName === 'SPAN' || el.onclick || el.style.cursor === 'pointer')) {
                    buttons.push(el);
                }
            });
        }

        return buttons;
    }

    // 移除所有高亮
    function removeAllHighlights() {
        if (!CONFIG.enableSkipBroadcast) return;

        document.querySelectorAll(`.${HIGHLIGHT_CLASS}`).forEach(el => {
            el.classList.remove(HIGHLIGHT_CLASS);
        });
    }

    // 高亮指定按钮
    function highlightButton(button) {
        if (!CONFIG.enableSkipBroadcast) return;

        removeAllHighlights();
        if (button) {
            button.classList.add(HIGHLIGHT_CLASS);
            currentFocusedButton = button;
        }
    }

    // 跳转到下一个按钮并高亮
    function jumpToNextButton(currentBtn) {
        if (!CONFIG.enableSkipBroadcast) return;

        const allButtons = getTargetButtons();
        if (allButtons.length === 0) {
            return;
        }

        let currentIndex = -1;

        // 找到当前按钮的索引
        if (currentBtn) {
            // 向上查找真正的按钮元素
            let actualButton = currentBtn;
            while (actualButton && !allButtons.includes(actualButton)) {
                actualButton = actualButton.parentElement;
            }

            if (actualButton) {
                currentIndex = allButtons.indexOf(actualButton);
            }
        } else if (currentFocusedButton) {
            currentIndex = allButtons.indexOf(currentFocusedButton);
        }

        // 计算下一个按钮的索引
        const nextIndex = (currentIndex + 1) % allButtons.length;
        const nextBtn = allButtons[nextIndex];

        if (nextBtn) {
            // 确保按钮可聚焦
            nextBtn.tabIndex = 0;

            // 滚动到视图中心
            nextBtn.scrollIntoView({
                behavior: 'smooth',
                block: 'center',
                inline: 'center'
            });

            // 快速聚焦和高亮
            setTimeout(() => {
                nextBtn.focus();
                highlightButton(nextBtn);

                // 重置处理标志
                isProcessing = false;
            }, 200);
        } else {
            isProcessing = false;
        }
    }

    // 跳转到上一个按钮并高亮
    function jumpToPreviousButton(currentBtn) {
        if (!CONFIG.enableSkipBroadcast) return;

        const allButtons = getTargetButtons();
        if (allButtons.length === 0) {
            return;
        }

        let currentIndex = -1;

        // 找到当前按钮的索引
        if (currentBtn) {
            // 向上查找真正的按钮元素
            let actualButton = currentBtn;
            while (actualButton && !allButtons.includes(actualButton)) {
                actualButton = actualButton.parentElement;
            }

            if (actualButton) {
                currentIndex = allButtons.indexOf(actualButton);
            }
        } else if (currentFocusedButton) {
            currentIndex = allButtons.indexOf(currentFocusedButton);
        }

        // 计算上一个按钮的索引（循环到最后一个）
        const prevIndex = currentIndex <= 0 ? allButtons.length - 1 : currentIndex - 1;
        const prevBtn = allButtons[prevIndex];

        if (prevBtn) {
            // 确保按钮可聚焦
            prevBtn.tabIndex = 0;

            // 滚动到视图中心
            prevBtn.scrollIntoView({
                behavior: 'smooth',
                block: 'center',
                inline: 'center'
            });

            // 快速聚焦和高亮
            setTimeout(() => {
                prevBtn.focus();
                highlightButton(prevBtn);

                // 重置处理标志
                isProcessing = false;
            }, 200);
        } else {
            isProcessing = false;
        }
    }

    // 点击事件处理
    function handleClick(e) {
        if (!CONFIG.enableSkipBroadcast) return;

        // 不阻止默认行为，让原始点击正常执行
        // 根据配置决定是否自动跳转到下一个按钮
        if (CONFIG.enableClickAutoJump) {
            if (isProcessing) {
                return;
            }

            // 设置处理标志
            isProcessing = true;

            // 快速跳转到下一个按钮
            setTimeout(() => {
                jumpToNextButton(e.target);
            }, 300);
        }
    }

    // 键盘事件处理 - F1、F2、小键盘2、小键盘5、箭头键和回车键
    function handleKeydown(e) {
        if (!CONFIG.enableSkipBroadcast || !CONFIG.enableKeyboardShortcuts) return;

        // 处理向上跳转的按键：F1、小键盘5、箭头上键
        if (e.key === 'F1' || e.key === '5' || e.key === 'ArrowUp') {
            // 检查是否是小键盘的5键
            if (e.key === '5' && e.location !== KeyboardEvent.DOM_KEY_LOCATION_NUMPAD) {
                return; // 不是小键盘的5键，忽略
            }
            
            e.preventDefault();

            if (isProcessing) {
                return;
            }

            const allButtons = getTargetButtons();
            if (allButtons.length === 0) {
                return;
            }

            // 设置处理标志
            isProcessing = true;

            // 跳转到上一个按钮（不执行点击）
            jumpToPreviousButton(currentFocusedButton);
        }
        // 处理向下跳转的按键：F2、小键盘2、箭头下键
        else if (e.key === 'F2' || e.key === '2' || e.key === 'ArrowDown') {
            // 检查是否是小键盘的2键
            if (e.key === '2' && e.location !== KeyboardEvent.DOM_KEY_LOCATION_NUMPAD) {
                return; // 不是小键盘的2键，忽略
            }
            
            e.preventDefault();

            if (isProcessing) {
                return;
            }

            const allButtons = getTargetButtons();
            if (allButtons.length === 0) {
                return;
            }

            // 设置处理标志
            isProcessing = true;

            // 跳转到下一个按钮（不执行点击）
            jumpToNextButton(currentFocusedButton);
        } else if (e.key === 'Enter' && CONFIG.enableEnterAutoJump) {
            // 回车键：如果当前聚焦的是目标按钮，执行点击后跳转到下一个
            const allButtons = getTargetButtons();
            if (allButtons.length === 0 || isProcessing) {
                return;
            }

            const focusedElement = document.activeElement;
            if (focusedElement && allButtons.includes(focusedElement)) {
                // 设置处理标志
                isProcessing = true;

                // 不阻止默认行为，让浏览器执行默认的点击
                // 延时跳转到下一个按钮
                setTimeout(() => {
                    jumpToNextButton(focusedElement);
                }, 300);
            }
        }
    }

    // 绑定跳过播报按钮事件
    function bindSkipBroadcastEvents() {
        if (!CONFIG.enableSkipBroadcast) return;

        const buttons = getTargetButtons();

        // 移除旧的事件监听器（避免重复绑定）
        buttons.forEach((btn, index) => {
            btn.removeEventListener('click', handleClick);
            btn.addEventListener('click', handleClick, false);
            btn.style.cursor = 'pointer';

            // 为调试添加标识
            btn.setAttribute('data-skip-index', index);
        });
    }

    // ==================== 初始化函数 ====================
    function initProductFloat() {
        if (!CONFIG.enableProductFloat) return;

        const observer = new MutationObserver((mutationsList) => {
            // 检查是否是我们自己的更新操作
            if (isUpdating) return;

            // 检查变化是否与产品信息相关
            let hasRelevantChange = false;
            for (const mutation of mutationsList) {
                if (mutation.type === 'childList') {
                    // 检查是否有相关元素的变化
                    const relevantNodes = Array.from(mutation.addedNodes).concat(Array.from(mutation.removedNodes));
                    for (const node of relevantNodes) {
                        if (node.nodeType === Node.ELEMENT_NODE) {
                            if (node.querySelector && (node.querySelector('[data-v-55875e22].every-product') ||
                                node.querySelector('[data-v-55875e22].sell-style') ||
                                node.closest('[data-v-55875e22].every-product') ||
                                node.closest('[data-v-55875e22].sell-style'))) {
                                hasRelevantChange = true;
                                break;
                            }
                        }
                    }
                    if (hasRelevantChange) break;
                }
            }

            if (hasRelevantChange) {
                handleUpdate();
            }
        });

        observer.observe(document.body, { childList: true, subtree: true });

        // 初始检查
        handleUpdate();
    }

    function initSkipBroadcast() {
        if (!CONFIG.enableSkipBroadcast) return;

        addSkipBroadcastStyles();
        bindSkipBroadcastEvents();

        // 绑定键盘事件
        if (CONFIG.enableKeyboardShortcuts) {
            document.removeEventListener('keydown', handleKeydown);
            document.addEventListener('keydown', handleKeydown);
        }

        // 动态监听DOM变化
        const observer = new MutationObserver(() => {
            setTimeout(bindSkipBroadcastEvents, 50);
        });

        observer.observe(document.body, {
            childList: true,
            subtree: true
        });
    }

    // ==================== 主初始化 ====================
    window.onload = function () {
        // 初始化产品信息浮窗功能
        initProductFloat();

        // 初始化跳过播报自动聚焦功能
        initSkipBroadcast();

        console.log('合并脚本已加载，当前配置:', CONFIG);
    };

    // 页面加载完成后初始化
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', function() {
            initProductFloat();
            initSkipBroadcast();
            console.log('合并脚本已加载，当前配置:', CONFIG);
        });
    } else {
        initProductFloat();
        initSkipBroadcast();
        console.log('合并脚本已加载，当前配置:', CONFIG);
    }
})();